package com.rxtxdemo.rxtxdemo.core;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;


/**
 * Created by Administrator on 2019/3/18 0018.
 * 串口工具类
 */
@Component
public class SerialPortTool
        //implements SerialPortEventListener
{
    private static final Logger logger = LoggerFactory.getLogger(SerialPortTool.class);//slf4j 日志记录器
//
//    /**
//     * 查找电脑上所有可用 com 端口
//     *
//     * @return 可用端口名称列表，没有时 列表为空
//     */
//    public static final ArrayList<String> findSystemAllComPort() {
//        /**
//         *  getPortIdentifiers：获得电脑主板当前所有可用串口
//         */
//        Enumeration<CommPortIdentifier> portList = CommPortIdentifier.getPortIdentifiers();
//        ArrayList<String> portNameList = new ArrayList<>();
//
//        /**
//         *  将可用串口名添加到 List 列表
//         */
//        while (portList.hasMoreElements()) {
//            CommPortIdentifier cpid = (CommPortIdentifier) portList.nextElement();
//            if (cpid.getPortType() == CommPortIdentifier.PORT_SERIAL) {
//                String portName = cpid.getName();//名称如 COM1、COM2....
//                portNameList.add(portName);
//            }
//
//        }
//        logger.info("可用的串口设备{}",portNameList);
//        return portNameList;
//    }
//
//    /**
//     * 打开电脑上指定的串口
//     *
//     * @param portName 端口名称，如 COM1，为 null 时，默认使用电脑中能用的端口中的第一个
//     * @param b        波特率(baudrate)，如 9600
//     * @param d        数据位（datebits），如 SerialPort.DATABITS_8 = 8
//     * @param s        停止位（stopbits），如 SerialPort.STOPBITS_1 = 1
//     * @param p        校验位 (parity)，如 SerialPort.PARITY_NONE = 0
//     * @return 打开的串口对象，打开失败时，返回 null
//     */
//    public static final SerialPort openComPort(String portName, int b, int d, int s, int p) {
//        CommPort commPort = null;
//        try {
//            //当没有传入可用的 com 口时，默认使用电脑中可用的 com 口中的第一个
//            if (StringUtils.isEmpty(portName)) {
//                List<String> comPortList = findSystemAllComPort();
//                if (comPortList != null && comPortList.size() > 0) {
//                    portName = comPortList.get(0);
//                }
//            }
//            logger.info("开始打开串口：portName=" + portName + ",baudrate=" + b + ",datebits=" + d + ",stopbits=" + s + ",parity=" + p);
//
//            //通过端口名称识别指定 COM 端口
//            CommPortIdentifier portIdentifier = CommPortIdentifier.getPortIdentifier(portName);
//            /**
//             * open(String TheOwner, int i)：打开端口
//             * TheOwner 自定义一个端口名称，随便自定义即可
//             * i：打开的端口的超时时间，单位毫秒，超时则抛出异常：PortInUseException if in use.
//             * 如果此时串口已经被占用，则抛出异常：gnu.io.PortInUseException: Unknown Application
//             */
//            commPort = portIdentifier.open(portName, 5000);
//            /**
//             * 判断端口是不是串口RS232
//             * public abstract class SerialPort extends CommPort
//             */
//            if (commPort instanceof SerialPort) {
//                SerialPort serialPort = (SerialPort) commPort;
//                /**
//                 * 设置串口参数：setSerialPortParams( int b, int d, int s, int p )
//                 * b：波特率（baudrate）
//                 * d：数据位（datebits），SerialPort 支持 5,6,7,8
//                 * s：停止位（stopbits），SerialPort 支持 1,2,3
//                 * p：校验位 (parity)，SerialPort 支持 0,1,2,3,4
//                 * 如果参数设置错误，则抛出异常：gnu.io.UnsupportedCommOperationException: Invalid Parameter
//                 * 此时必须关闭串口，否则下次 portIdentifier.open 时会打不开串口，因为已经被占用
//                 */
//                serialPort.setSerialPortParams(b, d, s, p);
//
//                logger.info("打开串口 " + portName + " 成功...");
//                return serialPort;
//            } else {
//                logger.error("当前端口 " + commPort.getName() + " 不是串口...");
//            }
//        } catch (NoSuchPortException e) {
//            e.printStackTrace();
//        } catch (PortInUseException e) {
//            logger.warn("串口 " + portName + " 已经被占用，请先解除占用...");
//            e.printStackTrace();
//        } catch (UnsupportedCommOperationException e) {
//            logger.warn("串口参数设置错误，关闭串口，数据位[5-8]、停止位[1-3]、验证位[0-4]...");
//            e.printStackTrace();
//            if (commPort != null) {//此时必须关闭串口，否则下次 portIdentifier.open 时会打不开串口，因为已经被占用
//                commPort.close();
//            }
//        }
//        logger.error("打开串口 " + portName + " 失败...");
//        return null;
//    }
//
//    /**
//     * 往串口发送数据
//     *
//     * @param serialPort 串口对象
//     * @param orders 待发送数据
//     */
//    public static void sendDataToComPort(SerialPort serialPort, byte[] orders) {
//        OutputStream outputStream = null;
//        try {
//            if (serialPort != null) {
//                outputStream = serialPort.getOutputStream();
//                outputStream.write(orders);
//                outputStream.flush();
//                logger.info("往串口 " + serialPort.getName() + " 发送数据：" + Arrays.toString(orders) + " 完成...");
//            } else {
//                logger.error("gnu.io.SerialPort 为null，取消数据发送...");
//            }
//        } catch (IOException e) {
//            e.printStackTrace();
//        } finally {
//            if (outputStream != null) {
//                try {
//                    outputStream.close();
//                } catch (IOException e) {
//                    e.printStackTrace();
//                }
//            }
//        }
//    }
//
//    /**
//     * @方法名称 :startRead
//     * @功能描述 :开始监听从端口中接收的数据
//     * @返回值类型 :void
//     * @param time
//     *            监听程序的存活时间，单位为秒，0 则是一直监听
//     */
//    public void startRead(SerialPort serialPort,CommPort commPort,int time) {
//
//        try {
//            InputStream inputStream = new BufferedInputStream(serialPort.getInputStream());
//        } catch (IOException e) {
//            throw new RuntimeException("获取端口的InputStream出错：" + e.getMessage());
//        }
//
//        try {
//            serialPort.addEventListener((SerialPortEventListener) this);
//        } catch (TooManyListenersException e) {
//            throw new RuntimeException(e.getMessage());
//        }
//
//        serialPort.notifyOnDataAvailable(true);
//
//        logger.info(String.format("开始监听来自'%1$s'的数据--------------", commPort.getName()));
//
//    }
//
//
//    /**
//     * 关闭串口
//     *
//     * @param  待关闭的串口对象
//     */
//    public static void closeComPort(SerialPort serialPort) {
//        if (serialPort != null) {
//            serialPort.close();
//            logger.info("关闭串口 " + serialPort.getName());
//        }
//    }
//
//    /**
//     * 数据接收的监听处理函数
//     */
//    @Override
//    public void serialEvent(SerialPortEvent arg0) {
//        switch (arg0.getEventType()) {
//            case SerialPortEvent.BI:/* Break interrupt,通讯中断 */
//            case SerialPortEvent.OE:/* Overrun error，溢位错误 */
//            case SerialPortEvent.FE:/* Framing error，传帧错误 */
//            case SerialPortEvent.PE:/* Parity error，校验错误 */
//            case SerialPortEvent.CD:/* Carrier detect，载波检测 */
//            case SerialPortEvent.CTS:/* Clear to send，清除发送 */
//            case SerialPortEvent.DSR:/* Data set ready，数据设备就绪 */
//            case SerialPortEvent.RI:/* Ring indicator，响铃指示 */
//            case SerialPortEvent.OUTPUT_BUFFER_EMPTY:/*
//             * Output buffer is
//             * empty，输出缓冲区清空
//             */
//                break;
//            case SerialPortEvent.DATA_AVAILABLE:/*
//             * Data available at the serial
//             * port，端口有可用数据。读到缓冲数组，输出到终端
//             */
//                byte[] readBuffer = new byte[1024];
//                String readStr = "";
//                String s2 = "";
//
//                try {
//
//                    while (inputStream.available() > 0) {
//                        inputStream.read(readBuffer);
//                        readStr += new String(readBuffer).trim();
//                    }
//
//                    s2 = new String(readBuffer).trim();
//
//        }
//    }
//
//    @Override
//    public void run() {
//        try {
//            Thread.sleep(threadTime);
//            serialPort.close();
//            log(String.format("端口''监听关闭了！", commPort.getName()));
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//    }
//
////    /**
////     * 16进制字符串转十进制字节数组
////     * 这是常用的方法，如某些硬件的通信指令就是提供的16进制字符串，发送时需要转为字节数组再进行发送
////     *
////     * @param strSource 16进制字符串，如 "455A432F5600"，每两位对应字节数组中的一个10进制元素
////     *                  默认会去除参数字符串中的空格，所以参数 "45 5A 43 2F 56 00" 也是可以的
////     * @return 十进制字节数组, 如 [69, 90, 67, 47, 86, 0]
////     */
////    public static byte[] hexString2Bytes(String strSource) {
////        if (strSource == null || "".equals(strSource.trim())) {
////            System.out.println("hexString2Bytes 参数为空，放弃转换.");
////            return null;
////        }
////        strSource = strSource.replace(" ", "");
////        int l = strSource.length() / 2;
////        byte[] ret = new byte[l];
////        for (int i = 0; i < l; i++) {
////            ret[i] = Integer.valueOf(strSource.substring(i * 2, i * 2 + 2), 16).byteValue();
////        }
////        return ret;
////    }

}
